package com.bitoon.basketdudes.web.mensajeria;
import com.bitoon.basketdudes.jpa.*;
import com.bitoon.basketdudes.jpa.PersistenceManager;


import java.io.*;
import java.util.*;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.XMLOutputter;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import javax.persistence.*;

import org.apache.log4j.Logger;

public class GestorHilos {

    private final int plataforma = 0; // 0 = XML, 1 = ...

    /* Rutas a los ficheros de la plataforma XML */
    private String pathMensajeria = "/proyectos/web/www.basketdudes.com/mensajeria/nueva/usersmsg";     //ruta ficheros con los id's de hilo de cada usuario
    private String pathMensHilos = "/proyectos/web/www.basketdudes.com/mensajeria/nueva/hilos";           //ruta hilo de mensajes monohilo
    private String pathIdsHilos = "/proyectos/web/www.basketdudes.com/mensajeria/nueva/hilos_ids.txt";  //contiene los ultimos id's de hilos creados,tanto mono como multihilo

    private int idUsuarioLogado;
    protected EntityManagerFactory emfBasket = null;

    private Logger log = Logger.getLogger(GestorHilos.class);

    public GestorHilos(int id_usuario){
        this.idUsuarioLogado = id_usuario;

        try {
            // JPA Units
            emfBasket = PersistenceManager.getInstance().getEntityManagerFactory("jpa_basket");
        } catch (Exception e) {
            log.error("[ERROR][constructor]: No se pudo conectar a la base de datos: ", e);
        }

    }

    public boolean Grabar(Hilo hilo,int idHilo){
        boolean retorno = true; //por defecto bien grabado
        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = escribirHiloXML(hilo,idHilo);
                break;
        }
        return retorno;
    }

    public List<Hilo> LeerHilos(){
        ArrayList<Hilo> retorno = null;

        log.debug("en LeerHilos: " + plataforma);

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = LeerMensajesUsuarioXML();
                break;
        }
        return retorno;
    }

    public boolean archivarHilo(String datosHilo){
        boolean retorno = true;

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = archivarConversacion(datosHilo);
                break;
        }
        return retorno;
    }
    
    public Hilo cargarConversacionXHR(String datosHilo){
        Hilo retorno = null;

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = cargarConversacion(datosHilo);
                break;
        }
        return retorno;
    }

    public void marcarConversacionXHR(String datosHilo,int id){
        
        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                marcarConversacionNoLeida(datosHilo,id,true);
                break;
        }
    }

    public String anadirManagerConversacionXHR(String datosHilo,String nicks){
        String managers="";

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                //marcarConversacionNoLeida(datosHilo,id);
                managers = anadirManagersAlHiloXML(datosHilo,nicks);
                break;
        }

        return managers;
    }

    /*public boolean abandonarHilo(Hilo h){
        boolean retorno = true;

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = abandonarConversacionXML(h);
                break;
        }
        return retorno;
    }*/

    public String eliminarMensajes(Hilo h,String mensajes){
        String retorno = "SUCCESS";

        //dependiendo de la plataforma leemos
        //de una forma u otra los hilos
        switch(plataforma){
            case 0:
                retorno = eliminarMensajesXML(h,mensajes);
                break;
        }
        return retorno;
    }

    /********************************************************
     *                  PLATAFORMA: XML                     *
     ********************************************************/

    private ArrayList<Hilo> LeerMensajesUsuarioXML(){
        Document doc = null;
        ArrayList<Hilo> listaHilos = null;
        EntityManager em = null;
        
        try {
            //primero cargar la lista con los id's de los mensajes de un usuario
            doc = obtenerXML(getIdUsuarioLogado(),pathMensajeria, true);

            log.debug("en LeerMensajesUsuarioXML: " + getIdUsuarioLogado());
            log.debug("doc: " + doc);

            if (doc != null) {
                Element root = doc.getRootElement();
                List<Element> l = null;
                l = root.getChildren();

                int ids = 0;
                Document doc_hilo = null;         //para leer el xml del hilo
                Element root_hilo = null;         //para sacar el root del hilo
                List<Element> listaElementosHilo = null;   //para recorrer cada elemento del hilo(mensajes)
                Hilo hilo = null;                 //para cada hilo, almcenamos sus OBJETOS mensaje
                listaHilos = new ArrayList<Hilo>();       //creamos la lista
                //para cada hilo en el que participa sacamos el ultimo msg
                for (Element el : l) {
                    ids = Integer.parseInt(el.getValue());
                    int estado = Integer.parseInt(el.getAttributeValue("estado"));
                    log.debug("[LeerMensajesUsuarioXML] estado: " +estado);
                    //primero compruebo que su estado no sea "archivado(2)"
                    if(estado!=2){
                        //para cada id de hilo , crear un objeto hilo, primero cargo su doc
                        doc_hilo = obtenerXML(ids,pathMensHilos,false);
                        if(doc_hilo!=null){
                            //ahora para cada hilo cargamos el ultimo mensaje en la lista de mensajes del hilo
                            hilo = new Hilo();
                            root_hilo = doc_hilo.getRootElement();
                            listaElementosHilo = root_hilo.getChildren();
                            MensajeUsuarioV2 elMensaje = null;

                            if(listaElementosHilo.size()>0){
                                //obtenemos el ultimo mensaje del hilo,que por orden es el más reciente siempre q su estado no sea 2,
                                //que es un mensaje de abandono y no nos interesa
                                elMensaje = new MensajeUsuarioV2();

                                int i=1;
                                do{
                                    elMensaje.setId(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("id")));
                                    elMensaje.setNumHilo(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("h")));
                                    //elMensaje.setTipoHilo(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-1).getAttributeValue("th")));
                                    elMensaje.setTipoUsuarioEmisor(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("te")));
                                    elMensaje.setFrom(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("f"));
                                    elMensaje.setFromUrl(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("fu"));
                                    elMensaje.setSender(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("s")));
                                    elMensaje.setTo(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("t"));
                                    elMensaje.setFecha(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("d"));
                                    elMensaje.setAsunto(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("a"));
                                    elMensaje.setTexto(acortarMensajePrevio(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("b"),95));
                                    elMensaje.setSentido(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("w")));
                                    elMensaje.setEstado(Integer.parseInt(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("es")));
                                    elMensaje.setIdsBorrados(listaElementosHilo.get(listaElementosHilo.size()-i).getAttributeValue("idsBorrados"));

                                    ++i;
                                }while ((elMensaje.getEstado()==2 && i<=listaElementosHilo.size()) || (elMensaje.esBorrado(getIdUsuarioLogado())==false && i<=listaElementosHilo.size()));
                                //para cada hilo,consulto el atributo estado del hilo y tambien quien lo creó
                                hilo.setEstado(Integer.parseInt(el.getAttribute("estado").getValue()));
                                hilo.setCreador(Integer.parseInt(el.getAttribute("creador").getValue()));
                                hilo.setId(Integer.parseInt(el.getText()));
                                //ahora meto el mensaje en el array de mensajes del hilo
                                hilo.getListaMensajes().add(elMensaje);
                                //meto los participantes
                                hilo.setParticipantes(el.getAttribute("participantes").getValue());

                                //saco los nicks de los participantes actuales del hilo
                                em = emfBasket.createEntityManager(); // check 07.08.2012
                                Query q = null;
                                String[] ids_participantes = root_hilo.getAttributeValue("ids").split(",");

                                Usuario u = null;
                                for ( int j=0;j<ids_participantes.length; ++j) {
                                    //si no es mensaje de sistema.el id0 = BasketDuddes
                                    if(Integer.parseInt(ids_participantes[j])>0){
                                        q = em.createNamedQuery("Usuario.findById");

                                        q.setParameter("id", Integer.parseInt(ids_participantes[j]));
                                        u = (Usuario)q.getSingleResult();
                                        //si es una conversacion entre el mismo
                                        if(u.getId()==getIdUsuarioLogado() && ids_participantes.length==1){
                                            hilo.getLista_participantes().add(u);
                                        }
                                        //todos menos el usuario actual
                                        if(u.getId()!=getIdUsuarioLogado()){
                                            hilo.getLista_participantes().add(u);
                                        }
                                    }else{
                                        u = new Usuario();
                                        u.setId(0);
                                        u.setNickMostrar("BasketDudes");
                                        u.setNick("BasketDudes");
                                        hilo.getLista_participantes().add(u);
                                    }
                                }
                                //meto el hilo en la lista de hilos
                                listaHilos.add(hilo);
                            }//fin si hay mensajes que mostrar
                        }//fin si existe el doc del hilo
                    }//fin si no es hilo archivado
                }//fin para cada hilo del usuario
                
                //como queremos verlos de forma que los ultimos sean los primeros, los
                //ordenamos de forma inversa con el ordenador de colecciones de Java
                //ordenarlos por fecha
                listaHilos = ordenarMensajesPorFecha(listaHilos);
            }
        } catch (Exception e) {
            log.error("Error", e);
        } finally {
            try { em.close(); } catch (Exception e) { } // revisado 09/08/2012
        }
        return listaHilos;
    }

    private String acortarMensajePrevio(String texto,int long_max){

        String retorno = "";
        int longitudmax = long_max; // limite de corte

        try{

            String[] texto_array = texto.split(" ");

            int i=0;
            String palabra="";
            boolean sw=false;
            while(i<texto_array.length && sw==false){
                palabra = texto_array[i];
                if((retorno.length()+palabra.length())<longitudmax){
                    retorno += palabra + " ";
                }else{
                    retorno = retorno.substring(0,retorno.length()-1)+"...";
                    sw=true;
                }
                ++i;
            }
        }catch(Exception e){ log.debug("[acortarMensajePrevio] error: ",e); }

        return retorno;
    }

    private ArrayList<Hilo> ordenarMensajesPorFecha(ArrayList<Hilo> listaHilos){

        /* recorre los hilos y los ordena por fecha de mas recientes a más viejos
          por el método de la burbuja mejorada */
        int pasadas = 0;
        int comparaciones = 0;
        boolean hayCambios = true;

        for(int i = 0; hayCambios ; i++){
            ++pasadas;
            hayCambios = false;
            for (int j = 0; j < listaHilos.size() - 1; j++) {
                  ++comparaciones;
                  if ((listaHilos.get(j).getListaMensajes().get(0).getFecha()).compareTo(listaHilos.get(j+1).getListaMensajes().get(0).getFecha())<0) {
                      Hilo aux = listaHilos.get(j);
                      listaHilos.set(j,listaHilos.get(j+1));
                      listaHilos.set(j+1, aux);
                      hayCambios = true;
                  }
             }
        }

        return listaHilos;
    }

    protected Document obtenerXML(int idUsuario, String path, boolean marcarComoLeidoAuto) {

        Document retorno = null;

        try {
            SAXBuilder parser = new SAXBuilder();
            log.debug("obtenerXML: " + getFicheroMensajes(idUsuario,path));
            File f = new File(getFicheroMensajes(idUsuario,path));
            if (f.exists()) {
                if (f.length() > 0) {
                    retorno = parser.build(f);
                }
            }
        } catch (JDOMException  jde) {
        } catch (Exception e) {
            log.error("Error", e);
        }
        
        return retorno;
    }

    public String getFicheroMensajes(int idUsuario,String path) {
        String retorno = path;

        DecimalFormat f1 = new DecimalFormat("00");
        DecimalFormat f2 = new DecimalFormat("00000");

        int n1 = idUsuario/1000000;
        int n2 = (idUsuario-n1*1000000)/10000;
        int n3 = (idUsuario-n1*1000000-n2*10000);

        retorno += f1.format(n1);
        retorno += "/" + f1.format(n2);
        retorno += "/" + f2.format(n3) + ".xml";

        return retorno;
    }

    public boolean escribirHiloXML(Hilo hilo,int hiloId) {
        boolean retorno = false;
        boolean nuevo = false;
        EntityManager em=null;
        
        try {
            Document doc = null;

            //por si es un nuevo mensaje
            int creador =0;
            //si se crea un mensaje que no ha creado el user logado
            if(hilo.getCreador()!=getIdUsuarioLogado()){
                creador = hilo.getCreador();
            }else{
                creador = getIdUsuarioLogado();
            }
            log.debug("[escribirHiloXML] creador: "+creador);

            //si es una respuesta
            if(hiloId>0){
                //obtengo el archivo hilo origen, si existe
                doc = obtenerXML(hiloId,pathMensHilos,false);
            }else{ 
                //tengo que mirar si existe un hilo ya entre estos participantes
                //y si es asi añadir el mensaje a ese hilo
                hiloId = comprobarSiExisteHilo(hilo.getCreador(),hilo.getParticipantes().split(","));
                
                log.debug("hiloId: "+ hiloId);


                if(hiloId==-1){
                    /*si es un mensaje nuevo
                    obtengo el id del ultimo hilo que hay que empezar*/
                    nuevo=true;
                    hiloId = ultimoIdHilo();
                    ++hiloId;
                }
                //obtengo el archivo hilo origen, si existe
                doc = obtenerXML(hiloId,pathMensHilos,false);
            }

            Element rootMensajes = null;

            if (doc != null) {
                log.debug("doc es distinto de null");
                rootMensajes = doc.getRootElement();

            } else {
                log.debug("doc es null");

                rootMensajes = new Element("hilo");
                String parts = ""; //ids en String
                String[] parts_array = hilo.getParticipantes().split(","); //ids en array
                for(int i=0;i<parts_array.length;++i){
                    parts = parts + parts_array[i];
                    if((i+1)<parts_array.length){
                       parts = parts + ",";
                    }
                }
                rootMensajes.setAttribute("ids", parts);
                rootMensajes.setAttribute("ids_originales", parts);
                doc = new Document(rootMensajes);
            }

            //creacion del mensaje y lo añadimos al rootDocument
            Element elMensaje = new Element("mensaje");

            int numMensajes = rootMensajes.getChildren().size();
            //id msg, idHilo, tipoHilo, tipo emisor, nickMostrar, nick, sender(id), Nick destinatario
            MensajeUsuarioV2 mensaje = hilo.getListaMensajes().get(0);

            elMensaje.setAttribute("id", Integer.toString(numMensajes+1));
            elMensaje.setAttribute("h",  Integer.toString(hiloId));
            elMensaje.setAttribute("te", Integer.toString(mensaje.getTipoUsuarioEmisor()));
            elMensaje.setAttribute("f",  mensaje.getFrom());
            elMensaje.setAttribute("fu", mensaje.getFromUrl());
            elMensaje.setAttribute("s",  Integer.toString(mensaje.getSender()));
            elMensaje.setAttribute("t",  mensaje.getTo());
            //fecha
            DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
            elMensaje.setAttribute("d", df.format(new java.util.Date())); // Fecha actual
            //mensaje: asunto y texto
            //elMensaje.setAttribute("a", mensaje.getAsunto());
            elMensaje.setAttribute("b", mensaje.getTexto());
            //sentido RECIBIDO/ENVIADO
            elMensaje.setAttribute("w", Integer.toString(MensajeUsuarioV2.RECIBIDO));
            rootMensajes.addContent(elMensaje);
            //estado del mensaje: no leido
            elMensaje.setAttribute("es", Integer.toString(mensaje.getEstado()));

            //idsBorrados,por defecto a vacio
            elMensaje.setAttribute("idsBorrados","");

            //Una vez sabemos a que hilo va, lo guardamos
            volcarDocAFichero(doc, hiloId,pathMensHilos);

            //si es un mensaje de abandono no hace falta informar a nadie del abandono
            if(mensaje.getEstado()!=2){
                //sino, si es un mensaje nuevo o una respuesta
                //debemos ahora introducir para cada usuario
                //el id del hilo al cual ahora pertenece este mensaje
                String[] ids_array = hilo.getParticipantes().split(",");
                
                //SI ES UN NUEVO HILO
                if(nuevo){
                    Usuario u = null;
                    em = emfBasket.createEntityManager(); // check 07.08.2012
                    Query q = null;

                    for ( int i=0;i<ids_array.length; ++i) {
                        //si es 0,es el administrador de basketdudes
                        if(Integer.parseInt(ids_array[i])>0){
                            q = em.createNamedQuery("Usuario.findById");
                            q.setParameter("id", Integer.parseInt(ids_array[i]));
                            u = (Usuario)q.getSingleResult();
                            log.debug("[escribir marcar] escribo el hilo");
                            escribirIdHiloEnBuzonUsuario(u.getId(),hiloId,creador,hilo.getParticipantes().split(","));
                        }
                    }

                    //por ultimo si todo ha ido bien, grabamos el nuevo id de hilo en el fichero hilos_ids.txt
                    grabarAumentoIdHilo();
                }else{
                    //SI ES UNA RESPUESTA
                    //poner a no leido el/los hilo(s) del otro(s) participante(s)
                    for ( int i=0;i<ids_array.length; ++i) {
                        //mientras no sea el que escribe el mensaje
                        log.debug("[escribir marcar] id: " + ids_array[i]);
                        String datosHilo = ""+hiloId;
                        marcarConversacionNoLeida(datosHilo, Integer.parseInt(ids_array[i]),false);

                         /*if(Integer.parseInt(ids_array[i])!=getIdUsuarioLogado()){
                           String datosHilo = ""+hiloId+"-0";
                           
                           marcarConversacionNoLeida(datosHilo, Integer.parseInt(ids_array[i]));

                          if(comprobarSiExisteHilo(Integer.parseInt(ids_array[i]),ids_array)==1){
                               //si algún usuario archivó el hilo, volver a
                               //ponerselo en su lista de hilos
                               marcarConversacionNoLeida(datosHilo, Integer.parseInt(ids_array[i]));
                           }else{
                               //ponemos el hilo a no leido
                               //log.debug("Existe el hilo");
                               if(esEstadoHiloNoLeido(hiloId)==false){
                                   log.debug("[escribirHiloXML] marcarConversacionNoLeida" + hiloId);
                                   marcarConversacionNoLeida(datosHilo, Integer.parseInt(ids_array[i]));
                               }
                           }
                        }else{

                        }*/

                    }
                 }
            }//fin si es un mensaje de abandono
 
        } catch (Exception e) {
            log.error("Error", e);
        } finally {
            try { em.close(); } catch (Exception e) { } // revisado 09/08/2012
        }

        return retorno;
    }

    public int comprobarSiExisteHilo(String id_manager1,String id_manager2){

        String[] participantes = {id_manager1,
                                  id_manager2};

        return comprobarSiExisteHilo(getIdUsuarioLogado(),participantes);
    }

    private int comprobarSiExisteHilo(int IdCreador,String[] participantes){
        int hiloId = -1;
        Document doc = null;

        try {
            doc = obtenerXML(IdCreador,pathMensajeria,false);

            Element rootMensajes = null;

            if (doc != null) {
                rootMensajes = doc.getRootElement();
                List<Element> l = null;
                l = rootMensajes.getChildren();
                HashSet<Integer> parts; //para recoger a los participantes de cada hilo
                int i=0;
                int cont =0;
                boolean sw=false;
                //recorremos cada hilo, vemos cuantos participantes hay y
                //los comparamos con los que tiene el hilo, si coincide el numero devolvemos
                //ese hilo,sino -1
                while(i<l.size() && sw==false){
                    //lista de participantes hilo "i"
                    parts = new HashSet(Arrays.asList(l.get(i).getAttributeValue("participantes").split(",")));
                    //comparo cada lista "i" con los participantes del nuevo mensaje
                    Iterator iter = parts.iterator();
                    while(iter.hasNext()){
                        int p = Integer.parseInt((String)iter.next());
                        //para cada participante del mensaje
                        for(String idPartMsg: participantes){
                            //log.debug("idHilo: " + Integer.parseInt(((String)idPart).trim()) + "idNuevoMsg: " + Integer.parseInt((String)idPartMsg));
                            //log.debug(Integer.parseInt(((String)idPart).trim())==Integer.parseInt(((String)idPartMsg).trim()));
                            if(p == Integer.parseInt((idPartMsg).trim())){
                                ++cont;
                            }
                        }
                    }
                    //comprobamos si han coincidido todos los participantes del hilo con
                    //los del nuevo mensaje, en cuyo caso devolvemops ese id de hilo
                    if(cont == participantes.length && participantes.length==parts.size()){
                        sw=true; //nos salimos porque hemos encontrado el hilo
                        //log.debug("Hilo encontrado: " + l.get(i).getText());
                        hiloId = Integer.parseInt(l.get(i).getText());
                    }
                    cont = 0;
                    ++i;
                }//fin while
            } else {
                log.debug("[comprobarSiExisteHilo] doc es null");
            }
        } catch (Exception e) {
            log.error("[comprobarSiExisteHilo] Error", e);
        }
        log.debug("[comprobarSiExisteHilo] " + hiloId);
        return hiloId;
    }

    private void escribirIdHiloEnBuzonUsuario(int idUsuario,int idHilo,int creador,String[] participantes){
        Document doc = null;

        try{
            doc = obtenerXML(idUsuario,pathMensajeria,false);

            Element rootMensajes = null;

            if (doc != null) {
                //log.debug("doc es distinto de null");
                rootMensajes = doc.getRootElement();
            } else {
                //log.debug("doc es null");
                rootMensajes = new Element("hilos");
                doc = new Document(rootMensajes);
            }

            //creamos un nuevo hijo con el id del nuevo hilo que le pertenece al usuario
            Element elHilo = new Element("id");
            if(idUsuario!=getIdUsuarioLogado()){
                elHilo.setAttribute("estado", "0");  //estado sin leer
            }else{
                elHilo.setAttribute("estado", "1");  //estado leido
            }
            elHilo.setAttribute("creador", Integer.toString(creador)); //creador
            //pasamos los participantes a un string separados por comas
            String parts = "";
            for(int i=0;i<participantes.length;++i){
                parts = parts + participantes[i];
                if((i+1)<participantes.length){
                   parts = parts + ",";
                }
            }
            elHilo.setAttribute("participantes", parts); //creador

            elHilo.addContent(Integer.toString(idHilo)); //id del hilo
            rootMensajes.addContent(elHilo);

            //escribimos el fichero
            volcarDocAFichero(doc, idUsuario,pathMensajeria);

        } catch (Exception e) {
            log.error("[escribirIdHilo] Error", e);
        }
    }

    protected void volcarDocAFichero(Document doc, int id, String path) {
        FileOutputStream fout = null;
        XMLOutputter out =null;
        File f = null;

        try {
            String filenameDestino = getFicheroMensajes(id,path);
            //comprobamos que existe el directorio primero - quito el /0000x.xml antes
            String dirDestino = filenameDestino.substring(0,(filenameDestino.length()-10));
            f = new File(dirDestino);
            if (f.isDirectory()){
                f = new File(filenameDestino);
                fout = new FileOutputStream(f);
                out = new XMLOutputter();
                out.output(doc, fout);
            }else{
                //no existe/n los directorios,los creamos - quito el /00000.xml antes
                filenameDestino = filenameDestino.substring(0,(filenameDestino.length()-10));
                boolean success = (new File(filenameDestino).mkdirs());
                if (success){
                    //log.debug("Directorios: "+ filenameDestino + " creados");
                    volcarDocAFichero(doc,id,path);
                }
            }
        } catch (Exception e) { log.error("volcarFichero", e);
        }finally{ // cerramos el fichero, para asegurarnos que se cierra tanto si todo va bien como si salta una excepcion.
             try{ if( fout != null){fout.close(); } // revisado 09/08/2012
             }catch (Exception e2){ log.error(e2); }
        }
    }

    private int ultimoIdHilo(){
        int hiloId = -1;

        try{
            StringTokenizer st = null;
            File f = new File(pathIdsHilos);
            if (f.exists()) {
                if (f.length() > 0) {

                    FileReader fr = new FileReader(f);
                    BufferedReader br = new BufferedReader(fr);
                    st = new StringTokenizer(br.readLine(),"#");
                }
            }else{ log.debug("[UltimoHilo] Fichero ids hilo NO encontrado"); }

            hiloId = Integer.parseInt(st.nextToken());

        }catch (Exception e){//Catch exception if any
          log.error("[UltimoHilo] Error: " + e.getMessage());
        }
        return hiloId;
    }

    private void grabarAumentoIdHilo(){
        int hiloId = -1;
        //Abre el fichero de isd de hilo y separamos el formato xn#xm
        //donde xn es el ultimo id monohilo y xm multihilo y aumentamos el que corresponda
        //dependiendo del tipo de mensaje escrito(mono o multihilo)
        try{
            File f = new File(pathIdsHilos);
            if (f.exists()) {
                if (f.length() > 0) {
                    
                    FileReader fr = new FileReader(f);
                    BufferedReader br = new BufferedReader(fr);
                    int cont = Integer.parseInt(br.readLine());
                    ++cont;
                    //escribimos la nueva fila con los ids de hilos
                    FileWriter fichero = null;
                    PrintWriter pw = null;

                    fichero = new FileWriter(pathIdsHilos);
                    pw = new PrintWriter(fichero);
                    pw.println(cont);

                    fichero.close();
                }
            }else{ log.debug("[UltimoHilo] Fichero ids hilo NO encontrado"); }

        }catch (Exception e){
          log.error("[UltimoHilo] Error: " + e.getMessage());
        }
    }

    public boolean archivarConversacion(String datosHilo){

        boolean retorno = true;

        try {
             //datos del mensaje: ID_HILO - ID_MSG
            String[] partes = datosHilo.split("-");
            int idHilo = Integer.parseInt(partes[0]);

            log.debug("[archivarConversacion]idHilo" + idHilo);

            Document doc = obtenerXML(idHilo,pathMensHilos,false);
            if (doc != null) {

                //elimino el id del usuario del hilo, a la vez compruebo si solo hay un id,soy el ultimo que
                //tiene la conversacion, si es asi borro el hilo
                Element root = doc.getRootElement();
                String idsUsers = root.getAttribute("ids").getValue();
                //log.debug("[borrarMensajeId] idsUsers: " + idsUsers);
                String array_ids[] = idsUsers.split(",");
                //log.debug("[borrarMensajeId] array_ids[]: " + array_ids);

                String idsNuevo = "";
                int i=0;
                int cont=0; //contara los ids que queden
                while(i<array_ids.length){
                   if( array_ids[i].trim().compareTo(Integer.toString(getIdUsuarioLogado()))!=0){
                        idsNuevo += array_ids[i];
                        cont++;
                        if((i+1)<array_ids.length){
                            idsNuevo += ",";
                        }
                    }
                    ++i;
                }

                //quito la ultima coma si la hubiera
                if(idsNuevo!=null && idsNuevo.compareTo("")!=0 && idsNuevo.charAt(idsNuevo.length()-1)==','){
                    idsNuevo = idsNuevo.substring(0,idsNuevo.length()-1);
                }
                
                //meto los nuevos ids del hilo menos el del usuario logado y guardo el hilo
                if(cont>0){
                    doc.getRootElement().setAttribute("ids", idsNuevo);
                    //log.debug("[archivarConversacion] cont="+cont);
                    volcarDocAFichero(doc, idHilo, pathMensHilos);
                    //log.debug("[borrarMensajeId] ids root: "+doc.getRootElement().getAttributeValue("ids"));
                }
                
                //elimino de su lista de hilos el id del hilo
                doc = obtenerXML(getIdUsuarioLogado(),pathMensajeria,false);
                ArrayList<Element> laux = new ArrayList<Element>();
                List children = doc.getRootElement().getChildren();

                Iterator iter = children.iterator();
                while (iter.hasNext()) {
                    Element child = (Element)iter.next();
                    if (child.getValue().equals(Integer.toString(idHilo))) {
                       //lo marco a estado=2 que quiere decir "hilo archivado"
                       //log.debug("[archivarConversacion] estado a 2");
                       child.setAttribute("estado", "2");
                    } 
                    laux.add(child);
                }

                // Grabar el nuevo doc con el elemento borrado
                 // Grabar el nuevo doc
                doc.getRootElement().removeContent();
                doc.getRootElement().setContent(laux);
                volcarDocAFichero(doc, getIdUsuarioLogado(), pathMensajeria);

                // Fijar otra vez los mensajes
                /*ArrayList e = LeerMensajesUsuarioXML();
                if (e!=null) {
                    setNumMensajesBandejaEntrada(e.size());
                }*/
            }
        } catch (Exception e) {
            retorno=false;
            log.error("[borrarMensajeId] Error: ",e);
        }

        return retorno;
    }
    
    private boolean marcarConversacionNoLeida(String idHilo,int id,boolean cargarConversacionXHR){

        boolean retorno = true; //siempre devuelve true menos cuando un hilo no existe

        try {
            log.debug("[marcarConversacionNoLeida] datosHilo: " + idHilo +" id: " + id);

            //seleciono el path para abrir el xml de hilos
            String path = pathMensajeria;
            
            Document doc=null;
            //si no pasamos un usuario en concreto, es el logado
            if(id==0){ 
                doc = obtenerXML(getIdUsuarioLogado(),path,cargarConversacionXHR);
            }else{ //sino es uno en concreto
                doc = obtenerXML(id,path,cargarConversacionXHR);
            }
            if (doc != null) {

                //busco el mensaje y lo marco a no leido
                Element nuevosMensajes = new Element("hilos");
                Document nuevoDoc = new Document(nuevosMensajes);
                List children = doc.getRootElement().getChildren();
               
                Iterator iter = children.iterator();
                while (iter.hasNext()) {
                    Element child = (Element)iter.next();
                    //log.debug("[marcarConversacionNoLeida] "+(child.getText().equals(idHilo)));
                    if (child.getText().equals(idHilo)) {
                        /*si el mensaje esta a leido lo dejo en no leido y viceversa
                         (si se pasa un id, no es un usuario logado,luego cambia la politica,
                          hay q marcarlo a no leido si o si) */
                        //log.debug("[marcarConversacionNoLeida] estado: "+child.getAttributeValue("estado"));
                        //0 - no leido, 1 - leido, 2 - archivado
                        int estado = Integer.parseInt(child.getAttributeValue("estado"));
                        if(estado==0 || estado==2){
                            if (cargarConversacionXHR) {
                                child.setAttribute("estado", "1");
                                //si es logado y estado=2
                                if(id==getIdUsuarioLogado() && estado==2){
                                    child.setAttribute("estado", "1");
                                }else{
                                    //si no es logado y estado=2
                                    if(estado==2){
                                        child.setAttribute("estado", "0");
                                    }
                                }
                            }
                        }else{
                            //si el estado es a leido lo marco a no leido
                            child.setAttribute("estado", "0");
                        }
                    }
                    iter.remove();
                    nuevoDoc.getRootElement().addContent(child);
                }

                // Grabar el nuevo doc con el elemento marcado a no leido
                if(id==0){
                    volcarDocAFichero(nuevoDoc, getIdUsuarioLogado(), path);
                }else{
                    volcarDocAFichero(nuevoDoc, id, path);
                }
            }else{
                retorno = false;
            }
        } catch (Exception e) {
            log.error("[marcarConversacionNoLeida] Error: ",e);
        }

        log.error("[marcarConversacionNoLeida] retorno: " +retorno);

        return retorno;
    }

    private Hilo cargarConversacion(String cargarHilo) {
        return cargarConversacion(cargarHilo, false);
    }

    private Hilo cargarConversacion(String cargarHilo, boolean marcarComoLeidoAuto) {

        Document doc = null;
        Hilo h = null;
        EntityManager em = null;
        //cargo la conversacion
        try {
            //cargar el hilo pedido
            String[] partes = cargarHilo.split("-");
            
            int idHilo = Integer.parseInt(partes[0]);
            //String id_mensaje = partes[1];

            doc = obtenerXML(idHilo,pathMensHilos,marcarComoLeidoAuto);

            if (doc != null) {
                Element root = doc.getRootElement();
                List<Element> l = null;
                l = root.getChildren();

                //tenemos que ver que el hilo tenga mensajes y su estado no sea 2,en cuyo caso redireccionamos
                //a la bandeja de entrada
                if(!l.isEmpty()){
                    MensajeUsuarioV2 elMensaje = null;
                    ArrayList<MensajeUsuarioV2> hilo = new ArrayList<MensajeUsuarioV2>();  //para cada hilo, almcenamos sus OBJETOS mensaje
                    for (Element el : l) {
                        if(esMsgBorradoPorUser(el.getAttributeValue("idsBorrados"), getIdUsuarioLogado())==0){
                            elMensaje = new MensajeUsuarioV2();
                            elMensaje.setId(Integer.parseInt(el.getAttributeValue("id")));
                            elMensaje.setNumHilo(Integer.parseInt(el.getAttributeValue("h")));
                            elMensaje.setTipoUsuarioEmisor(Integer.parseInt(el.getAttributeValue("te")));
                            elMensaje.setFrom(el.getAttributeValue("f"));
                            elMensaje.setFromUrl(el.getAttributeValue("fu"));
                            elMensaje.setSender(Integer.parseInt(el.getAttributeValue("s")));
                            elMensaje.setTo(el.getAttributeValue("t"));
                            elMensaje.setFecha(el.getAttributeValue("d"));
                            //elMensaje.setAsunto(el.getAttributeValue("a"));
                            elMensaje.setTexto(el.getAttributeValue("b"));
                            elMensaje.setSentido(Integer.parseInt(el.getAttributeValue("w")));
                            elMensaje.setEstado(Integer.parseInt(el.getAttributeValue("es")));
                            elMensaje.setIdsBorrados(el.getAttributeValue("idsBorrados"));
                            hilo.add(elMensaje);
                        }
                    }

                    //si hay mensajes que mostrar en la conversacion
                    if(hilo.size()>0){
                        //como queremos verlos de forma que los ultimos sean los primeros, los
                        //ordenamos de forma inversa con el ordenador de colecciones de Java
                        //Collections.reverse(hilo);
                        h = new Hilo();
                        h.setListaMensajes(hilo);
                        //para cada hilo,consulto el atributo estado del hilo y tambien quien lo creó

                        log.debug("marcar?? " + marcarComoLeidoAuto);

                        if (marcarComoLeidoAuto) {
                            log.debug("marcando!!");
                            h.setEstado(1);
                        }
                        h.setId(idHilo);

                        //meto los ids participantes, no son los originales,sino los que estan actualmente
                        //dentro de la conversación
                        String ids = root.getAttribute("ids").getValue();
                        h.setParticipantes(ids);

                        //meto los nicksMostrar de los participantes
                        em = emfBasket.createEntityManager(); // check 07.08.2012
                        Query q = null;
                        Usuario u = null;
                        String ids_array[] = root.getAttribute("ids").getValue().split(",");

                        for ( int i=0;i<ids_array.length; ++i) {
                            if(Integer.parseInt(ids_array[i])>0){
                                q = em.createNamedQuery("Usuario.findById");

                                q.setParameter("id", Integer.parseInt(ids_array[i]));
                                u = (Usuario)q.getSingleResult();
                                if(getIdUsuarioLogado()!=u.getId()){
                                    h.getLista_participantes().add(u);
                                }
                            }else{
                                u = new Usuario();
                                u.setId(0);
                                u.setNickMostrar("BasketDudes");
                                u.setNick("BasketDudes");
                                h.getLista_participantes().add(u);
                            }
                        }

                        //log.debug("listaHilos: " +h.getLista_participantes().size());

                        //grabo el hilo como no leido si no lo estaba
                        if(esEstadoHiloNoLeido(idHilo)){
                            if (marcarComoLeidoAuto) {
                                marcarConversacionNoLeida(cargarHilo,0,false);
                            }
                        }
                    }//si estan todos los mensajes borrados devuelvo null
                }//si no hay mensajes devuelvo null
            }
        }catch (Exception e) {
            log.error("Error", e);
        }finally {
            try { em.close(); } catch (Exception e) { } // revisado 09/08/2012
        }
        return h;
    }

    private boolean esEstadoHiloNoLeido(int idHilo){

        //seleciono el path para abrir el xml de hilos del usuario
        Document doc = obtenerXML(getIdUsuarioLogado(),pathMensajeria,false);
        boolean retorno = true; //por defecto esta sin leer

        if (doc != null) {
            Element root = doc.getRootElement();
            List<Element> l = null;
            l = root.getChildren();

            for(Element e:l){
                if (e.getText().equals(Integer.toString(idHilo))) {

                    //log.debug("[esEstadoHiloNoLeido] estado: " + e.getAttributeValue("estado"));
                    if(e.getAttributeValue("estado").compareTo("1")==0){
                        retorno = false;
                    }
                }
            }
        }

        return retorno;
    }

    private String anadirManagersAlHiloXML(String datosHilo,String managers){

        String retorno = "";
        Usuario u = null;

        //log.debug("[anadirManagersAlHiloXML] entro: " + managers);

        try {
             //datos del mensaje: ID_HILO - ID_MSG
            String[] partes = datosHilo.split("-");
            int idHilo = Integer.parseInt(partes[0]);
            String id_mensaje = partes[1];

            //sacar los nicks de los managers, comprobar que cada uno existe en BD
            boolean nicks_validos = true;

            ArrayList<Usuario> users = dameManagersNuevos(managers);

            for(int i=0;i<users.size();++i){
                u = users.get(i);
                retorno = retorno + u.getNickMostrar();
                if((i+1)<users.size() ){
                    retorno = retorno + ", ";
                }
            }

            if(retorno.length()>0 && retorno.charAt(retorno.length()-2)==','){
                retorno = retorno.substring(0, (retorno.length()-2));
            }else{
                if(retorno.length()==0){
                    nicks_validos=false;
                }
            }

            //si todos los nicks son válidos
            if(nicks_validos && retorno.length()>0){

                //abro el hilo y compruebo que no esta cada nick ya en el hilo
                // si no esta en el hilo,meter su id dentro y crear en su usersmsg00 un 
                //registro con el hilo o añadirselo, si esta en hilo no se devuelve ni se hace nada
                Document doc = obtenerXML(idHilo,pathMensHilos,false);
                if (doc != null) {

                    Element root = doc.getRootElement();
                    String idsUsers = root.getAttribute("ids").getValue();
                    String array_ids[] = idsUsers.split(",");

                    //recojo los nuevos managers,su numero y sus ids
                    ArrayList datos = hayNuevosManagersAnadirHilo(idsUsers,users);
                    int cont = (Integer)datos.get(0);
                    String idsNuevo = (String)datos.get(1);
                    ArrayList<String> anadidos = (ArrayList<String>)datos.get(2);

                    //crear en su usersmsg00 una referencia al hilo para cada nuevo manager
                    for(String usno : anadidos){
                        array_ids = (idsUsers+idsNuevo).split(",");
                        escribirIdHiloEnBuzonUsuario(Integer.parseInt(usno),idHilo,0,array_ids);
                    }

                    //meto los nuevos ids en el hilo, actualizo los ficheros de los hilos que tiene un user
                    if(cont>0){
                        doc.getRootElement().setAttribute("ids", (doc.getRootElement().getAttribute("ids").getValue()+idsNuevo)); //los que estan participando actualmente

                        //actualizamos los originales si y solo si,no ha participado alguna vez en la conversacion
                        doc.getRootElement().setAttribute("ids_originales", actualizarManagersOriginalesHilo(idsNuevo,doc.getRootElement().getAttribute("ids_originales").getValue())); //estos sirven para saber los q han participado alguna vez

                        volcarDocAFichero(doc, idHilo, pathMensHilos);
                        //actualizar los participantes de cada usersmg00 no añadido
                        log.debug("[anadirManagersAlHiloXML] no_anadidos: "+array_ids.length);
                        for(String usno : array_ids){
                            //actualizar participantes
                            actualizarParticipantes(Integer.parseInt(usno),idHilo,doc.getRootElement().getAttribute("ids_originales").getValue());
                        }
                    }else{
                        retorno="";
                    }
                }
            }
        } catch (Exception e) {
            retorno="%error%";
            log.error("[anadirManagersAlHiloXML] Error: ",e);
        }
        
        //devolver los nicksMostrar de los managers que se han unido al hilo
        return retorno;
    }

    protected String actualizarManagersOriginalesHilo(String idsNuevo,String ids_originales){

        /*Devuelve todos los managers que no esten ya en ids_originales(interseccion)*/
        String retorno=ids_originales;
        String[] nuevos = idsNuevo.split(",");
        String[] originales = ids_originales.split(",");

        boolean esta=false;

        for(String n: nuevos ){
            esta=false;
            int i=0;
            while(i<originales.length && esta==false){
                String o = originales[i];
                if(n.compareTo(o)==0){
                    esta=true;
                }
                ++i;
            }
            if(!esta){
                retorno += n+",";
            }
        }

        if(retorno.length()>0 && retorno.charAt(retorno.length()-1)==','){
            retorno = retorno.substring(0, (retorno.length()-1));
        }

        log.debug("[actualizarManagersOriginalesHilo] "+retorno);
        return retorno;
    }

    private ArrayList hayNuevosManagersAnadirHilo(String idsUsers,ArrayList<Usuario> users){

        String array_ids[] = idsUsers.split(",");

        String idsNuevo = "";
        ArrayList<String> anadidos = new ArrayList<String>();
        int i=0;
        int cont=0; //contara añadidos
        while(i<users.size()){
            boolean sw=false;
            int j=0;
            while(j<array_ids.length && sw==false){
                //compruebo que el nuevo usuario a añadir en el hilo no esta ya en el,sino no lo añado
                if( array_ids[j].trim().compareTo(Integer.toString(users.get(i).getId()))==0){
                    sw=true;
                }
                ++j;
            }
            //si no esta en el hilo,meter su id dentro y crear en su usersmsg00 una referencia al hilo
            if(sw==false){
                anadidos.add(Integer.toString(users.get(i).getId()));
                idsNuevo += "," + Integer.toString(users.get(i).getId());
                cont++;
            }
            ++i;
        }
        
        //compongo un arrayList para devolver en cada posicion diferentes datos
        ArrayList datos = new ArrayList();
        datos.add(cont);
        datos.add(idsNuevo);
        datos.add(anadidos);
        return datos;
    }

    private ArrayList<Usuario> dameManagersNuevos(String managers){

        Query q = null;
        EntityManager em = null;
        ArrayList<Usuario> users = new ArrayList<Usuario>();

        try{
            String[] nicks = managers.split(",");
            Usuario u = null;
            String n="";

            em = emfBasket.createEntityManager(); // check 07.08.2012
            
            for(int i=0;i<nicks.length;++i){
                //busco el manager en la BD
                n = nicks[i];
                q = em.createNamedQuery("Usuario.findByNickAdmin");
                q.setParameter("nick", n.toLowerCase().trim());

                try{
                    u = (Usuario)q.getSingleResult();
                }catch(NoResultException ex){ u =null;log.debug("[dameManagersNuevos] user: " + n + " no esta en BD");}

                if(u!=null){
                    //compongo el nuevo string con los nickMostrar de los nuevos participantes
                    users.add(u);
                }
            }
        } catch (Exception e) {
            log.error("[dameManagersNuevos] Error: ",e);
        } finally {
            try { em.close(); } catch (Exception e) { } // revisado 09/08/2012
        }
        return users;

    }

    private void actualizarParticipantes(int id_usuario,int idHilo,String idsNuevos){
        //seleciono el path para abrir el xml de hilos del usuario
        Document doc = obtenerXML(id_usuario,pathMensajeria,false);

        if (doc != null) {
            Element root = doc.getRootElement();
            List<Element> l = null;
            l = root.getChildren();

            List children = doc.getRootElement().getChildren();

            Iterator iter = children.iterator();
            Element child = null;
            ArrayList<Element> laux = new ArrayList<Element>();
            while (iter.hasNext()) {
                child = (Element)iter.next();

                if (child.getValue().equals(Integer.toString(idHilo))) {
                    child.setAttribute("participantes", idsNuevos);

                }
                laux.add(child);
            }

            doc.getRootElement().removeContent();
            doc.getRootElement().setContent(laux);
            volcarDocAFichero(doc, id_usuario, pathMensajeria);
        }
    }

    /*private boolean abandonarConversacionXML(Hilo h){
        
        Document doc = obtenerXML(h.getId(),pathMensHilos);

        if (doc != null) {

            String[] idsParticipantes = doc.getRootElement().getAttributeValue("ids").split(",");

            log.debug(" id_hilo"+h.getId() + " part: " + doc.getRootElement().getAttributeValue("ids"));

            //poner en su usersmsg00 id del hilo como abandonada la conversacion en el mensaje id = x
        }
        return true;
    }*/

    private String eliminarMensajesXML(Hilo h,String mensajes){

        String retorno = "SUCCESS";

        log.debug("[eliminarMensajesXML] " + mensajes+"-");

        try{
            Document doc = obtenerXML(h.getId(),pathMensHilos,false);

            if (doc != null) {
                Element root = doc.getRootElement();
                List<Element> l = null;
                l = root.getChildren();

                String[] mensajes_array = mensajes.split(", ");

                //limpio los mensajes
                for(int i=0;i<mensajes_array.length;++i){
                    mensajes_array[i] = mensajes_array[i].trim();
                    if(mensajes.length()>0 && mensajes.charAt(mensajes.length()-1)==','){
                        mensajes = mensajes.substring(0, (mensajes.length()-1));
                    }
                }

                List children = doc.getRootElement().getChildren();
                Iterator iter = children.iterator();
                ArrayList<Element> laux = new ArrayList<Element>();

                //para cada mensaje del hilo,vemos si hay q eliminarle
                int cont=0;
                int msgBorrados=0;
                while (iter.hasNext()) {
                    Element child = (Element)iter.next();
                    //para cada mensaje pasado a borrar
                    for(String m: mensajes_array){
                        if (Integer.parseInt(child.getAttributeValue("id"))==Integer.parseInt(m)) {
                            //marcarle como borrado
                            if(((String)child.getAttribute("idsBorrados").getValue()).compareTo("")==0){
                                //si el primer usuario que quiere tener borrado esete mensaje,le meto sin coma
                                child.setAttribute("idsBorrados", ((String)child.getAttribute("idsBorrados").getValue()+getIdUsuarioLogado()));
                            }else{
                                //si hay q añadir un usuario le concateno con coma
                                child.setAttribute("idsBorrados", ((String)child.getAttribute("idsBorrados").getValue()+","+getIdUsuarioLogado()));
                            }
                            cont++;
                        }
                    }
                    msgBorrados += esMsgBorradoPorUser((String)child.getAttribute("idsBorrados").getValue(),getIdUsuarioLogado());
                    //si el mensaje esta borrado por todos los participantes del hilo, no debe
                    //ser puesto de nuevo en la lista de mensajes,ya que nadie llegaría a ellos y ocupan espacio
                    log.debug("[eliminarMensajesXML] id_mensaje" + child.getAttribute("id").getValue());
                    if(!esMensajeBorradoPorTodos((String)child.getAttribute("idsBorrados").getValue(),(String)doc.getRootElement().getAttribute("ids_originales").getValue())){
                        laux.add(child);
                    }
                }

                //si todos los mensajes estan borrados, tengo q archivar su referencia al hilo "usersmsg00"
                //porq los mensajes tienen que estar disponibles para los demas usuarios
                log.debug("msgBorrados="+msgBorrados+"laux.size: "+laux.size() + " - " + (msgBorrados==laux.size()));
                //si estan todos los mensajes borrados o si ya no hay
                if(msgBorrados==laux.size() || laux.isEmpty()){
                    //archivamos la conversacion
                    archivarConversacion(Integer.toString(h.getId()));
                    retorno = "redirect";
                }

                // Grabar el nuevo doc
                doc.getRootElement().removeContent();
                doc.getRootElement().setContent(laux);
                volcarDocAFichero(doc, h.getId(), pathMensHilos);
            }

        } catch (Exception e) {
            retorno = "ERROR";
            log.error("[eliminarMensajesXML] Error: ",e);
        }

        log.debug("[eliminarMensajesXML] retorno: " +retorno);

        return retorno;
    }

    private boolean esMensajeBorradoPorTodos(String idsBorrados,String participantes){

        log.debug("[BorradoPorTodos] idsBorrados: "+idsBorrados+"parts: "+participantes);

        boolean sw=false;

        if(idsBorrados.length()>0 && participantes.length()>0){

            String[] borrados_array = idsBorrados.split(",");
            String[] participantes_array = participantes.split(",");

            log.debug("[BorradoPorTodos]" +(borrados_array.length==participantes_array.length));

            sw = borrados_array.length==participantes_array.length;
        }
        
        return sw;
    }

    private int esMsgBorradoPorUser(String idsBorrados,int id_user){
        /* Devuelve 1 si tiene el mensaje borrado o 0 si no*/

        //log.debug("idsBorrados: -" + idsBorrados + "- id_user: " + id_user);

        int retorno=0;

        if(idsBorrados.compareTo("")!=0){
            String[] idsborrados_array = idsBorrados.split(",");
            int i=0;
            while(i<idsborrados_array.length && retorno==0){
                if(Integer.parseInt(idsborrados_array[i])==id_user){
                    retorno=1;
                }
                ++i;
            }
        }

        return retorno;
    }

    public int getPlataforma() {
        return plataforma;
    }

    public String getPathMensHilos() {
        return pathMensHilos;
    }

    public void setPathMensHilos(String pathMensHilos) {
        this.pathMensHilos = pathMensHilos;
    }

    public int getIdUsuarioLogado() {
        return idUsuarioLogado;
    }

    public void setIdUsuarioLogado(int idUsuarioLogado) {
        this.idUsuarioLogado = idUsuarioLogado;
    }
}